import { CozeAPI, ChatStatus, COZE_CN_BASE_URL, RoleType } from '@coze/api'
import pool from '../config/db.js'

/**
 * @swagger
 * tags:
 *   name: AI服务
 *   description: AI聊天和故事生成服务
 */

/**
 * AI服务类，处理与AI聊天、故事生成、用户行为分析等功能
 * @class
 */
class AIService {
  /**
   * 创建AIService实例
   * @constructor
   */
  constructor() {
    // 初始化 Coze API 客户端
    this.client = new CozeAPI({
      token: process.env.COZE_API_TOKEN,
      baseURL: COZE_CN_BASE_URL,
    })
  }

  /**
   * 发送消息给AI并获取回复
   * @async
   * @param {string} message - 用户发送的消息文本
   * @param {string|number} userId - 用户ID
   * @param {string|null} fileUrl - 文件URL，如图片或音频
   * @param {string|null} fileType - 文件类型，'image'或'audio'
   * @returns {Promise<Object>} 包含AI回复的响应对象
   */
  async chat(message, userId, fileUrl = null, fileType = null) {
    try {
      // 确保 userId 是字符串且有效
      const userIdStr = String(userId || 'default_user');
      
      console.log('Processing chat message:', { userId: userIdStr, message, fileUrl, fileType });
      console.log('Using bot ID:', process.env.COZE_BOT_ID);
      console.log('API token available:', !!process.env.COZE_API_TOKEN);

      // 处理带有文件的消息
      let userMessage = message;
      if (fileUrl) {
        // 根据文件类型添加适当的描述
        const fileDesc = fileType === 'image' ? '图片' : '音频';
        userMessage = `${message || ''}\n\n用户发送了${fileDesc}：${fileUrl}`;
      }

      // 简化请求，只包含必要参数
      const response = await this.client.chat.createAndPoll({
        bot_id: process.env.COZE_BOT_ID,
        user_id: userIdStr,
        additional_messages: [
          {
            role: RoleType.User,
            content: userMessage,
            content_type: 'text'
          }
        ],
        stream: false
      });

      console.log('Chat response status:', response.chat.status);
      console.log('Chat response messages count:', response.messages.length);

      // 检查对话状态
      if (response.chat.status !== ChatStatus.COMPLETED) {
        throw new Error(`对话未完成，当前状态: ${response.chat.status}`)
      }

      // 找到AI的回复消息
      const aiMessages = response.messages.filter(
        msg => msg.role === 'assistant' && msg.type === 'answer'
      )
      
      if (!aiMessages.length) {
        throw new Error('未找到AI回复')
      }
      
      const reply = aiMessages[0].content || '抱歉，我现在无法回答。'

      // 保存对话记录，包含文件URL
      await this.saveChatMessage(userIdStr, 'user', message, fileUrl, fileType)
      await this.saveChatMessage(userIdStr, 'ai', reply)

      return {
        success: true,
        data: {
          message: reply
        }
      }
    } catch (error) {
      console.error('Chat API error:', error)
      
      // 确保这里也使用 userIdStr
      const userIdStr = String(userId || 'default_user');
      
      // 保存用户消息和默认回复
      await this.saveChatMessage(userIdStr, 'user', message, fileUrl, fileType)
      await this.saveChatMessage(userIdStr, 'ai', '抱歉，我现在无法回答。')
      
      return {
        success: false,
        message: error.message || '聊天服务暂时不可用',
        data: {
          message: '抱歉，我现在无法回答。'
        }
      }
    }
  }

  /**
   * 保存聊天消息到数据库
   * @async
   * @param {string} userId - 用户ID
   * @param {string} role - 消息发送者角色，'user'或'ai'
   * @param {string} content - 消息内容
   * @param {string|null} fileUrl - 文件URL，如果有的话
   * @param {string|null} fileType - 文件类型，'image'或'audio'
   * @returns {Promise<void>}
   */
  async saveChatMessage(userId, role, content, fileUrl = null, fileType = null) {
    try {
      await pool.query(
        `INSERT INTO chat_messages (user_id, role, content, file_url, file_type, created_at) 
         VALUES (?, ?, ?, ?, ?, NOW())`,
        [userId, role, content, fileUrl, fileType]
      )
    } catch (error) {
      console.error('Error saving chat message:', error)
    }
  }

  /**
   * 获取用户聊天历史
   * @async
   * @param {string} userId - 用户ID
   * @returns {Promise<Array>} 聊天消息数组
   */
  async getChatHistory(userId) {
    try {
      const [rows] = await pool.query(
        `SELECT id, role, content, 
        file_url, file_type, DATE_FORMAT(created_at, '%Y-%m-%d %H:%i:%s') as created_at 
        FROM chat_messages 
        WHERE user_id = ? 
        ORDER BY created_at ASC`,
        [userId]
      )
      return rows
    } catch (error) {
      console.error('Error getting chat history:', error)
      return []
    }
  }

  /**
   * 生成故事
   * @async
   * @static
   * @param {string} prompt - 故事生成提示
   * @param {string|number} userId - 用户ID
   * @returns {Promise<Object>} 生成的故事内容
   */
  static async generateStory(prompt, userId) {
    try {
      // 创建临时客户端
      const client = new CozeAPI({
        token: process.env.COZE_API_TOKEN,
        baseURL: COZE_CN_BASE_URL,
      });
      
      const response = await client.chat.createAndPoll({
        bot_id: process.env.COZE_BOT_ID,
        user_id: String(userId),
        additional_messages: [{
          role: RoleType.User,
          content: prompt,
          content_type: 'text'
        }],
      });

      // 找到AI的回复消息
      const aiMessages = response.messages.filter(
        msg => msg.role === 'assistant' && msg.type === 'answer'
      );
      
      return {
        success: true,
        story: aiMessages.length ? aiMessages[0].content : '抱歉，无法生成故事。'
      }
    } catch (error) {
      console.error('Story generation error:', error)
      return {
        success: false,
        error: error.message,
        story: '抱歉，故事生成服务暂时不可用。'
      }
    }
  }

  /**
   * 保存分析结果到数据库
   * @async
   * @static
   * @param {string} userId - 用户ID
   * @param {string} type - 分析类型
   * @param {Object} data - 分析数据
   * @param {Object} result - 分析结果
   * @returns {Promise<number>} 插入的ID
   */
  static async saveAnalysis(userId, type, data, result) {
    try {
      const [res] = await pool.query(
        `INSERT INTO ai_analysis (user_id, type, data, result) 
         VALUES (?, ?, ?, ?)`,
        [userId, type, JSON.stringify(data), JSON.stringify(result)]
      )
      return res.insertId
    } catch (error) {
      console.error('Error saving analysis:', error)
      throw error
    }
  }

  /**
   * 分析用户行为
   * @async
   * @static
   * @param {string} userId - 用户ID
   * @param {Object} data - 用户行为数据
   * @returns {Promise<Object>} 分析结果
   */
  static async analyzeUserBehavior(userId, data) {
    try {
      const client = new CozeAPI({
        token: process.env.COZE_API_TOKEN,
        baseURL: COZE_CN_BASE_URL,
      });
      
      const response = await client.chat.createAndPoll({
        bot_id: process.env.COZE_BOT_ID,
        user_id: String(userId),
        additional_messages: [{
          role: RoleType.User,
          content: `分析以下用户行为数据:\n${JSON.stringify(data)}`,
          content_type: 'text'
        }],
      });

      const aiMessages = response.messages.filter(
        msg => msg.role === 'assistant' && msg.type === 'answer'
      );
      
      const analysis = aiMessages.length ? aiMessages[0].content : '无法分析数据。';
      await this.saveAnalysis(userId, 'user_behavior', data, analysis);

      return {
        success: true,
        analysis
      }
    } catch (error) {
      console.error('Analysis error:', error)
      return {
        success: false,
        error: error.message,
        analysis: '分析服务暂时不可用。'
      }
    }
  }

  /**
   * 获取商品推荐
   * @async
   * @static
   * @param {string} userId - 用户ID
   * @param {Object} userBehavior - 用户行为数据
   * @returns {Promise<Object>} 推荐结果
   */
  static async getProductRecommendations(userId, userBehavior) {
    try {
      const client = new CozeAPI({
        token: process.env.COZE_API_TOKEN,
        baseURL: COZE_CN_BASE_URL,
      });
      
      const response = await client.chat.createAndPoll({
        bot_id: process.env.COZE_BOT_ID,
        user_id: String(userId),
        additional_messages: [{
          role: RoleType.User,
          content: `基于以下用户行为推荐商品:\n${JSON.stringify(userBehavior)}`,
          content_type: 'text'
        }],
      });

      const aiMessages = response.messages.filter(
        msg => msg.role === 'assistant' && msg.type === 'answer'
      );
      
      const recommendations = aiMessages.length ? aiMessages[0].content : '暂无推荐。';
      await this.saveAnalysis(
        userId, 
        'product_recommendation', 
        userBehavior, 
        recommendations
      );

      return {
        success: true,
        recommendations
      }
    } catch (error) {
      console.error('Recommendation error:', error)
      throw error
    }
  }
}

// 创建单例实例
const aiService = new AIService()
export default aiService 